…er test

Two fresh-agent test rounds surfaced three issues; all fixed:

- kaggle CLI: the `kaggle` package has no __main__, so `python -m kaggle`
  crashes with ModuleNotFoundError. Correct entry point is `kaggle.cli`.
- venv instruction used `python -m venv`, which fails on Debian/Ubuntu
  systems where only `python3` exists (no python-is-python3). Changed to
  `python3 -m venv`. After activation `python` resolves correctly.
- pip-install fails on modern PEP 668 systems without a venv. README now
  leads with the venv setup before the install step, with a note on why.

Also: prepare_data.py now catches Kaggle CalledProcessError and prints
the two most common root causes (rules not accepted / kaggle.json perms)
with the exact URL to accept the competition rules.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

The previous prepare_data.py used pandas df.sample(random_state=42), which
produced parquets with shape, fraud rate, and DT range matching the original
case-study but DIFFERENT row content — baseline AUC came out at 0.9023
instead of the case-study's 0.9102. Recovered the original ad-hoc prep
recipe from a Claude Code session transcript and rewrote to match. Two
recipe details that turned out to matter:

1. Stratified train subsample preserving fraud rate, using a single global
   np.random.seed(42) followed by sequential np.random.choice calls (NOT
   pandas df.sample). The val subsample inherits the advanced RNG state.
2. Label-encode using categories from concat(train, val), and include
   "string" alongside "object" in select_dtypes — pandas 3 uses StringDtype
   for string columns and skips them when only "object" is included,
   silently leaving them as raw strings (which would then crash LightGBM
   or be dropped before fit).

Verified locally: re-running this prepare_data.py from a fresh Kaggle
download produces parquets with SHA-256s
  train: a2d7a6740559975b8e6d89bd605f1e29791dd7d3fee8abc6449552bbc18d29ae
  val:   8b426c8bf7fa845bc234dbce304b1107fd295143fac2398bab97b78805f50753
matching the case-study originals exactly. Baseline AUC = 0.910171.

README updated to reflect the now-deterministic 0.9102 baseline (the
previous "0.910 because we removed the leak" gloss was misleading — the
parquets themselves were different from the case-study). Reframed the
0.914 reference as the case-study's leaky-baseline AUC for clarity.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Recent CLI versions ship important fixes — most relevant here, 0.3.31
added queue-mode submit recovery (`_recover_queue_suggest`) and a
native `AutoResumePolicy` that together make the transient
`Failed to submit result` race invisible to the user. Anyone with an
older weco in their venv (e.g. operators reusing weco-gpu's pinned
0.3.25) was hitting this race and silently terminating runs short of
their step budget.

Switching the install command to `pip install --upgrade -r requirements.txt`
ensures users picking up this example always get the latest fixes,
regardless of what's pre-installed in their venv. Comment in the README
explains why we never pin weco-cli.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…to -loose

The previous fraud-detection example exposed `build_features(train_df, val_df)`
in a single file. The agent could (and frequently did) `pd.concat([train, val])`
and silently introduce time-leakage in encoders. We measured the inflation at
0.001-0.005 AUC depending on parquet contents, and found that prompt-level
"fit on train only" warnings only achieved ~67% compliance across seeds.

The new fraud-detection/ example uses a fit/transform interface:
  features.py: class FeatureBuilder with fit(X_train, y_train) + transform(X)
  model.py:    train_and_evaluate(X_train, y_train, X_val, y_val) -> float
  evaluate.py: frozen orchestrator that strips isFraud, calls fb.fit then
               fb.transform twice, and runs the model.

This kills two classes of leakage at the interface:
- isFraud is dropped before X reaches features.py (target leakage out).
- val data is never visible to fit() (time leakage out).
- transform() has no y argument (val labels can't influence val features).

Weco optimizes:
- features.py and model.py separately for scope=features / scope=model
- both together (`--sources features.py model.py`) for scope=full
The file boundary IS the scope boundary — no leaky helper module needed.

Existing single-file example renamed to fraud-detection-loose/ and kept as
a comparison artifact. README in fraud-detection/ links to it.

Baseline AUC: 0.909132 (deterministic; ~0.001 below the loose version's
0.910171 — that's the leakage inflation in the loose baseline).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

The features.py docstring says y_train is a pd.Series (so users can call
.values, .map, .to_dict on it for OOF target encoding). Earlier evaluate.py
passed the result of .values.astype("int32") which is a numpy ndarray,
breaking any proposal that did `y_train.values` or `y_train.map(...)`.

Sanity-checked on a 3-seed Weco run: with the Series fix, proposals proceed
past step 1 instead of crashing on AttributeError.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>